package util;

import javax.swing.SwingUtilities;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CompletableFuture;

/**
 * AI助手服务类 - DeepSeek API集成
 */
public class AIService {
    private static final String API_URL = "https://api.deepseek.com/chat/completions";
    private static final String API_KEY = "sk-00bd991d61df441f94ca24a0ed2c4abd";

    public interface AIResponseCallback {
        void onSuccess(String response);

        void onError(String error);

        void onProgress(String partialResponse);

        void onStreamStart();

        void onStreamEnd();
    }

    /**
     * 异步调用AI服务
     */
    public static CompletableFuture<String> getChatResponse(String userMessage, String category) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                return callDeepSeekAPI(userMessage, category);
            } catch (Exception e) {
                throw new RuntimeException("AI服务调用失败: " + e.getMessage(), e);
            }
        });
    }

    /**
     * 带回调的异步调用
     */
    public static void getChatResponseWithCallback(String userMessage, String category, AIResponseCallback callback) {
        CompletableFuture.supplyAsync(() -> {
            try {
                return callDeepSeekAPI(userMessage, category);
            } catch (Exception e) {
                SwingUtilities.invokeLater(() -> callback.onError("网络错误: " + e.getMessage()));
                return null;
            }
        }).thenAccept(response -> {
            if (response != null) {
                SwingUtilities.invokeLater(() -> callback.onSuccess(response));
            }
        }).exceptionally(throwable -> {
            SwingUtilities.invokeLater(() -> callback.onError("AI服务异常: " + throwable.getMessage()));
            return null;
        });
    }

    /**
     * 支持流式传输的异步调用
     */
    public static void getChatResponseWithStreaming(String userMessage, String category, AIResponseCallback callback) {
        CompletableFuture.runAsync(() -> {
            try {
                SwingUtilities.invokeLater(callback::onStreamStart);
                callDeepSeekAPIWithStreaming(userMessage, category, callback);
                SwingUtilities.invokeLater(callback::onStreamEnd);
            } catch (Exception e) {
                SwingUtilities.invokeLater(() -> callback.onError("流式传输错误: " + e.getMessage()));
            }
        });
    }

    /**
     * 调用DeepSeek API
     */
    private static String callDeepSeekAPI(String userMessage, String category) throws IOException {
        URL url = URI.create(API_URL).toURL();
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        // 设置请求头
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-Type", "application/json");
        connection.setRequestProperty("Authorization", "Bearer " + API_KEY);
        connection.setDoOutput(true);
        connection.setConnectTimeout(10000); // 10秒连接超时
        connection.setReadTimeout(30000); // 30秒读取超时

        // 构建系统提示词
        String systemPrompt = buildSystemPrompt(category);

        // 构建请求体
        String requestBody = buildRequestBody(systemPrompt, userMessage);

        // 发送请求
        try (OutputStream os = connection.getOutputStream()) {
            byte[] input = requestBody.getBytes(StandardCharsets.UTF_8);
            os.write(input, 0, input.length);
        }

        // 读取响应
        int responseCode = connection.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            try (BufferedReader br = new BufferedReader(
                    new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
                StringBuilder response = new StringBuilder();
                String responseLine;
                while ((responseLine = br.readLine()) != null) {
                    response.append(responseLine);
                }

                return parseResponse(response.toString());
            }
        } else {
            // 读取错误响应
            try (BufferedReader br = new BufferedReader(
                    new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8))) {
                StringBuilder errorResponse = new StringBuilder();
                String errorLine;
                while ((errorLine = br.readLine()) != null) {
                    errorResponse.append(errorLine);
                }
                throw new IOException("API调用失败 (HTTP " + responseCode + "): " + errorResponse.toString());
            }
        }
    }

    /**
     * 构建系统提示词
     */
    private static String buildSystemPrompt(String category) {
        String basePrompt = "你是一个富有经验且极具耐心的学习导师，就像学生最信任的朋友一样。" +
                "你的任务是提供深入、全面且实用的建议，帮助学生真正解决问题。\n\n" +
                "## 回复风格要求：\n" +
                "- **详细全面**：不要担心回复长度，提供充分的细节和解释\n" +
                "- **结构清晰**：使用标题、列表、分段等让内容易读\n" +
                "- **实用可操作**：给出具体的步骤和方法，而非泛泛而谈\n" +
                "- **温暖人性化**：像朋友一样关心学生的感受，使用鼓励性语言\n" +
                "- **举例说明**：通过具体例子让抽象概念更易理解\n\n";

        switch (category.toLowerCase()) {
            case "自由提问":
                return basePrompt + "**自由交流模式**\n" +
                        "在自由提问模式下，你可以：\n" +
                        "• 回答任何学习和生活相关的问题\n" +
                        "• 进行深入的学术讨论和思考\n" +
                        "• 提供创意想法和解决方案\n" +
                        "• 像朋友一样自然对话交流\n" +
                        "• 帮助思考复杂问题的多个角度\n" +
                        "• 分享知识和见解\n\n" +
                        "请保持开放和包容的态度，根据学生的具体问题提供最有价值的回答。" +
                        "鼓励深入思考，支持创新想法，让对话更加自由和富有启发性。";

            case "学习方法":
                return basePrompt + "**专业领域：学习方法指导**\n" +
                        "作为学习方法专家，你需要：\n" +
                        "• 分析不同学习风格和认知类型\n" +
                        "• 提供具体的学习技巧和策略\n" +
                        "• 解释学习原理和科学依据\n" +
                        "• 推荐适合的学习工具和方法\n" +
                        "• 帮助学生找到最适合自己的学习方式\n\n" +
                        "请详细回答，不要吝惜篇幅，让学生真正掌握有效的学习方法。";

            case "时间管理":
                return basePrompt + "**专业领域：时间管理与效率提升**\n" +
                        "作为时间管理专家，你需要：\n" +
                        "• 帮助分析时间使用现状和问题\n" +
                        "• 提供个性化的时间规划方案\n" +
                        "• 介绍各种时间管理工具和技巧\n" +
                        "• 解决拖延症和注意力不集中问题\n" +
                        "• 平衡学习、工作和生活的时间分配\n\n" +
                        "请提供详细的操作指南，包括具体的时间表模板和执行建议。";

            case "学习资源":
                return basePrompt + "**专业领域：学习资源推荐与利用**\n" +
                        "作为学习资源专家，你需要：\n" +
                        "• 推荐高质量的学习材料和平台\n" +
                        "• 评估不同资源的优缺点\n" +
                        "• 指导如何有效利用各种学习工具\n" +
                        "• 分享获取优质免费资源的方法\n" +
                        "• 根据不同需求个性化推荐资源\n\n" +
                        "请详细介绍每个推荐资源的特点和使用方法，让学生能够充分利用。";

            case "答疑解惑":
                return basePrompt + "**专业领域：学术问题解答与思维引导**\n" +
                        "作为答疑导师，你需要：\n" +
                        "• 深入分析问题的本质和关键点\n" +
                        "• 提供清晰的解题思路和方法\n" +
                        "• 引导学生独立思考和解决问题\n" +
                        "• 拓展相关知识点和应用场景\n" +
                        "• 培养学生的批判性思维能力\n\n" +
                        "如果问题超出知识范围，请诚实说明，并建议获取准确信息的途径。详细解答每个问题。";

            case "心理支持":
                return basePrompt + "**专业领域：学习心理支持与情绪管理**\n" +
                        "作为心理支持专家，你需要：\n" +
                        "• 理解学生的情感需求和压力来源\n" +
                        "• 提供积极正面的心理建议和技巧\n" +
                        "• 帮助建立健康的学习心态\n" +
                        "• 分享应对焦虑和挫折的方法\n" +
                        "• 鼓励学生建立自信和成长mindset\n\n" +
                        "请用温暖、理解的语气，提供详细的心理调节方法和实践建议。";

            default:
                return basePrompt + "**综合学习助手**\n" +
                        "你可以在以下方面为学生提供全面帮助：\n" +
                        "• 学习方法和技巧指导\n" +
                        "• 时间管理和效率提升\n" +
                        "• 学习资源推荐\n" +
                        "• 学术问题解答\n" +
                        "• 心理支持和鼓励\n\n" +
                        "请根据具体问题，提供详细、全面且人性化的回答。不要担心回复过长，学生需要充分的指导。";
        }
    }

    /**
     * 构建请求体
     */
    private static String buildRequestBody(String systemPrompt, String userMessage) {
        return String.format("""
                {
                    "model": "deepseek-chat",
                    "messages": [
                        {
                            "role": "system",
                            "content": "%s"
                        },
                        {
                            "role": "user",
                            "content": "%s"
                        }
                    ],
                    "max_tokens": 1000,
                    "temperature": 0.7,
                    "stream": false
                }
                """, escapeJsonString(systemPrompt), escapeJsonString(userMessage));
    }

    /**
     * 构建流式请求体
     */
    private static String buildStreamingRequestBody(String systemPrompt, String userMessage) {
        return String.format("""
                {
                    "model": "deepseek-chat",
                    "messages": [
                        {
                            "role": "system",
                            "content": "%s"
                        },
                        {
                            "role": "user",
                            "content": "%s"
                        }
                    ],
                    "max_tokens": 1000,
                    "temperature": 0.7,
                    "stream": true
                }
                """, escapeJsonString(systemPrompt), escapeJsonString(userMessage));
    }

    /**
     * 解析API响应
     */
    private static String parseResponse(String jsonResponse) {
        try {
            // 简单的JSON解析 - 查找content字段
            String contentMarker = "\"content\":\"";
            int startIndex = jsonResponse.indexOf(contentMarker);
            if (startIndex == -1) {
                return "抱歉，AI服务暂时无法处理您的请求。";
            }

            startIndex += contentMarker.length();
            int endIndex = jsonResponse.indexOf("\"", startIndex);

            // 处理转义字符
            StringBuilder content = new StringBuilder();
            for (int i = startIndex; i < endIndex; i++) {
                char c = jsonResponse.charAt(i);
                if (c == '\\' && i + 1 < endIndex) {
                    char nextChar = jsonResponse.charAt(i + 1);
                    switch (nextChar) {
                        case 'n':
                            content.append('\n');
                            i++;
                            break;
                        case 't':
                            content.append('\t');
                            i++;
                            break;
                        case '\\':
                            content.append('\\');
                            i++;
                            break;
                        case '"':
                            content.append('"');
                            i++;
                            break;
                        default:
                            content.append(c);
                    }
                } else {
                    content.append(c);
                }
            }

            return content.toString().trim();
        } catch (Exception e) {
            return "抱歉，解析AI响应时出现错误。请重试。";
        }
    }

    /**
     * JSON字符串转义
     */
    private static String escapeJsonString(String str) {
        if (str == null)
            return "";
        return str.replace("\\", "\\\\")
                .replace("\"", "\\\"")
                .replace("\n", "\\n")
                .replace("\r", "\\r")
                .replace("\t", "\\t");
    }

    /**
     * 获取预设问题
     */
    public static String[] getQuickQuestions(String category) {
        switch (category.toLowerCase()) {
            case "自由提问":
                return new String[] {
                        "你好，我想聊聊最近的学习困惑",
                        "能和我讨论一个有趣的问题吗？",
                        "我有一些想法想听听你的看法",
                        "帮我分析一下这个现象...",
                        "我想了解更多关于...",
                        "能给我一些建议吗？"
                };
            case "学习方法":
                return new String[] {
                        "如何提高记忆效率？",
                        "怎样做好学习笔记？",
                        "如何克服学习拖延？",
                        "怎么提高专注力？"
                };
            case "时间管理":
                return new String[] {
                        "如何制定有效的学习计划？",
                        "怎样平衡学习和休息？",
                        "如何利用碎片时间学习？",
                        "怎么安排复习时间？"
                };
            case "学习资源":
                return new String[] {
                        "推荐一些在线学习平台",
                        "有哪些好用的学习工具？",
                        "如何选择适合的教材？",
                        "推荐一些学习类APP"
                };
            case "答疑解惑":
                return new String[] {
                        "遇到难题该怎么办？",
                        "如何寻求学习帮助？",
                        "怎么提高解题能力？",
                        "如何整理错题本？"
                };
            case "心理支持":
                return new String[] {
                        "学习压力大怎么办？",
                        "如何保持学习动力？",
                        "考试焦虑如何缓解？",
                        "怎么建立自信心？"
                };
            default:
                return new String[] {
                        "如何提高学习效率？",
                        "请给一些学习建议",
                        "如何制定学习计划？",
                        "怎样保持学习动力？"
                };
        }
    }

    /**
     * 流式调用DeepSeek API
     */
    private static void callDeepSeekAPIWithStreaming(String userMessage, String category, AIResponseCallback callback)
            throws IOException {
        URL url = URI.create(API_URL).toURL();
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();

        // 设置请求头
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-Type", "application/json");
        connection.setRequestProperty("Authorization", "Bearer " + API_KEY);
        connection.setRequestProperty("Accept", "text/event-stream");
        connection.setDoOutput(true);
        connection.setConnectTimeout(10000); // 10秒连接超时
        connection.setReadTimeout(60000); // 60秒读取超时（流式传输需要更长时间）

        // 构建系统提示词和请求体
        String systemPrompt = buildSystemPrompt(category);
        String requestBody = buildStreamingRequestBody(systemPrompt, userMessage);

        // 发送请求
        try (OutputStream os = connection.getOutputStream()) {
            byte[] input = requestBody.getBytes(StandardCharsets.UTF_8);
            os.write(input, 0, input.length);
        }

        // 读取流式响应
        int responseCode = connection.getResponseCode();
        if (responseCode == HttpURLConnection.HTTP_OK) {
            try (BufferedReader br = new BufferedReader(
                    new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {

                StringBuilder fullResponse = new StringBuilder();
                String line;

                while ((line = br.readLine()) != null) {
                    if (line.startsWith("data: ")) {
                        String jsonData = line.substring(6).trim();

                        // 检查是否是结束标记
                        if ("[DONE]".equals(jsonData)) {
                            break;
                        }

                        try {
                            // 解析流式响应中的内容
                            String partialContent = parseStreamingResponse(jsonData);
                            if (!partialContent.isEmpty()) {
                                fullResponse.append(partialContent);

                                // 发送进度更新
                                final String currentResponse = fullResponse.toString();
                                SwingUtilities.invokeLater(() -> callback.onProgress(currentResponse));
                            }
                        } catch (Exception e) {
                            // 忽略解析错误，继续处理下一行
                        }
                    }
                }

                // 发送最终结果
                final String finalResponse = fullResponse.toString().trim();
                if (!finalResponse.isEmpty()) {
                    SwingUtilities.invokeLater(() -> callback.onSuccess(finalResponse));
                } else {
                    SwingUtilities.invokeLater(() -> callback.onError("未收到有效的AI响应"));
                }
            }
        } else {
            // 读取错误响应
            try (BufferedReader br = new BufferedReader(
                    new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8))) {
                StringBuilder errorResponse = new StringBuilder();
                String errorLine;
                while ((errorLine = br.readLine()) != null) {
                    errorResponse.append(errorLine);
                }
                throw new IOException("流式API调用失败 (HTTP " + responseCode + "): " + errorResponse.toString());
            }
        }
    }

    /**
     * 解析流式响应
     */
    private static String parseStreamingResponse(String jsonData) {
        try {
            // 简单的JSON解析 - 查找delta content字段
            String deltaMarker = "\"delta\":{\"content\":\"";
            int startIndex = jsonData.indexOf(deltaMarker);
            if (startIndex == -1) {
                return "";
            }

            startIndex += deltaMarker.length();
            int endIndex = jsonData.indexOf("\"", startIndex);
            if (endIndex == -1) {
                return "";
            }

            String content = jsonData.substring(startIndex, endIndex);

            // 处理转义字符
            return content.replace("\\n", "\n")
                    .replace("\\t", "\t")
                    .replace("\\\"", "\"")
                    .replace("\\\\", "\\");

        } catch (Exception e) {
            return "";
        }
    }
}
